home *** CD-ROM | disk | FTP | other *** search
/ SuperHack / SuperHack CD.bin / CODING / GRAPHICS / GMSMTH01.ZIP / MAPDEMO.DSK (.txt) < prev    next >
Encoding:
Turbo C Context File  |  1995-12-13  |  37.3 KB  |  972 lines
  1. Turbo C Context File 
  2. ..\LIB\GAMELIB.LIB
  3. MAPDEMO.C
  4. ..\LIB\GAMELIB.LIB
  5. MAPDEMO.C
  6. SPRFILE.H
  7. SPRFILE.C
  8. SPFILE.C
  9. MAIN.H
  10. C:\BC\MKSPRITE\*.C
  11. \BC\MKSPRITE\*.C
  12. \BC\GAME\*.C
  13. SPRITE.H
  14. \BC\TCMGAME\SOURCE\*.ASM
  15. \BC\GAME\*.H
  16. \BC\TCMGAME\SPRDEMO\*.C
  17. \BC\TCMGAME\INCLUDE\*.H
  18. \BC\TCMGAME\SOURCE\*.C
  19. t.gui
  20. c:\bc\gui\*.pbm brucepal.pal
  21. *.pbm brucepal.pal
  22. explode.seq brucepal.pal
  23. explode1.seq brucepal.pal
  24. robot.seq brucepal.pal
  25. tank.seq brucepal.pal
  26. stlball.spr brucepal.pal
  27. robot.spr brucepal.pal
  28. batsuit.spr brucepal.pal
  29. tank.spr brucepal.pal
  30. explode1.spr brucepal.pal
  31. ebolt.spr brucepal.pal
  32. BACKWARD *.ASM
  33.  void *.c 
  34. OK *.ASM
  35. drawScreen
  36. update
  37. fade_out
  38. fade_in
  39. draw_screen
  40. moveY
  41. controlY
  42. moveX
  43. collision
  44. writing
  45. saving
  46. []= "
  47. (char far *)
  48. palette
  49. moveX
  50. moveY
  51. controlY
  52. controlX
  53. C:\BC\TCMGAME\*.*
  54. C:\BC\TCMGAME\LIB\*.LIB
  55. C:\BC\MAPDEMO\*.C
  56. C:\BC\GAME\MAPDEMO\*.C
  57. C:\BC\GAME\LIB
  58. C:\BC\GAME\LIB\*.LIB
  59. s->curr_bitmap,fp
  60. *bminfo,15d
  61. bitMapCount
  62. bitmapCount
  63. s->icurr_bitmap
  64. hd->num_bitmaps
  65. prev_ibitmap
  66. bminfo
  67. *bminfo
  68. bminfo.type
  69. bminfo->type
  70. nextTurn
  71. fast_tick
  72. currBufferPage > 0
  73. index = 17
  74. C:\BC\TCMGAME\SOURCE\GMALLOC.C
  75. C:\BC\TCMGAME\SOURCE\GUI.C
  76. C:\BC\TCMGAME\SOURCE\GUITOOL3.C
  77. C:\BC\INCLUDE\STDIO.H
  78. C:\BC\TCMGAME\SOURCE\MAPDEMO.C
  79. C:\BC\TCMGAME\SOURCE\MAPDEMO.C
  80. C:\BC\MAPDEMO\MAPDEMO.C
  81. C:\BC\TCMGAME\SOURCE\FADE.C
  82. C:\BC\TCMGAME\SOURCE\MODE13.C
  83. C:\BC\TCMGAME\SOURCE\MODE13.C
  84. C:\BC\GAME\MAPDEMO\MAPDEMO.C
  85. C:\BC\TCMGAME\SOURCE\MAKE13.C
  86. C:\BC\TCMGAME\SOURCE\MAKE13.C
  87. C:\BC\TCMGAME\SOURCE\MAKELIB.C
  88. C:\BC\TCMGAME\SOURCE\MAKECBM.C
  89. C:\BC\GAME\MAPDEMO\MAPDEMO.C
  90. _   /* set palette */
  91.    strcpy( pal_name, argv[2]);
  92.    if ( load_palette(pal_name, (char far *)palette) )
  93.       die("error getting palette");
  94.    setvgapalette((char far *)palette);
  95.    if ( gui_load_gadget( get_gui_path("ed_map.gui"), gui_path ) )
  96.       die("ERROR loading ed_map.gui");
  97.    set_gui_def_colors_to_gadget( PB_EXIT );
  98.    init_events(get_gui_path("crshair.cbm"));
  99.    if ( !mouse_present )
  100.       die("Mouse driver not loaded.");
  101.    /* set aside mem etc.. for 50 erase rects, not to exceed 32k */
  102.    init_gb_erase(50, 32000);
  103.    memcpy( mapFileName, argv[1], 127 );
  104.    mapFileName[127] = '\0';
  105.    // if a groups file specified, use it, otherwise use the groups file
  106.    // specified in the map_t struct.
  107.    if ( argc > 3 )
  108.       {
  109.       memcpy( edInfoFname, argv[3], 127 );
  110.       edInfoFname[127] = '\0';
  111.       map= load_edit_tile_map( mapFileName, edInfoFname, MAPWIN_LEFT, MAPWIN_RIGHT,
  112.                                                     MAPWIN_TOP, MAPWIN_BOTTOM );
  113.       }
  114.    else
  115.       map= load_edit_tile_map( mapFileName, NULL, MAPWIN_LEFT, MAPWIN_RIGHT,
  116.                                                  MAPWIN_TOP, MAPWIN_BOTTOM );
  117.    if (map == NULL)
  118.       die( "Can't open map file" );
  119. // initialize editing
  120.    numObjects= getNumLibObjects(map->dress_lib);
  121.    numAnims=   getNumLibObjects(map->anim_lib);
  122.    initEditing();
  123.    edited=0;
  124. // draw screen, flip pages, draw on other page too
  125.    page = 0;
  126.    draw_all_tiles(map);
  127.    draw_low_dressings(map);
  128.    draw_high_dressings(map);
  129.    x_page_flip(0,0);
  130.    page= page ? 0 : 1;
  131.    draw_all_tiles(map);
  132.    draw_low_dressings(map);
  133.    draw_high_dressings(map);
  134.    task= TASK_NONE;
  135.    while ( !done )
  136.       {
  137.       move_state = NO_MOVE;
  138.       /* erase old stuff */
  139.       draw_erase_rects(&(gb_h[page]));
  140.       // make this page match other page due to any drawing done last frame
  141.       if ( dirty )
  142.          draw_all_tiles(map);
  143.       else
  144.          update_tiles(map);
  145.       // draw mouse dress either under or over hidresses where mouse is if
  146.       //   editing dresses
  147.       switch( action )
  148.          {
  149.          case PLACE_HIDRESS:
  150.             draw_low_dressings(map);
  151.             draw_high_dressings(map);
  152.             if ( !deleteOn && !showAttribsOn )
  153.                drawDressMouse(mouse_x, mouse_y);
  154.             draw_spritebank_offs( map->spr_bank,
  155.                                   map->x-map->win_left, map->y-map->win_top );
  156.             break;
  157.          case PLACE_LODRESS:
  158.             draw_low_dressings(map);
  159.             if ( !deleteOn && !showAttribsOn )
  160.                drawDressMouse(mouse_x, mouse_y);
  161.             draw_high_dressings(map);
  162.             draw_spritebank_offs( map->spr_bank,
  163.                                   map->x-map->win_left, map->y-map->win_top );
  164.             break;
  165.          case PLACE_ANIMS:
  166.             draw_low_dressings(map);
  167.             draw_high_dressings(map);
  168.             draw_spritebank_offs( map->spr_bank,
  169.                                   map->x-map->win_left, map->y-map->win_top );
  170.             if ( !deleteOn && !showAttribsOn )
  171.                drawDressMouse(mouse_x, mouse_y);
  172.             break;
  173.          case PLACE_TILE:
  174.             draw_low_dressings(map);
  175.             draw_high_dressings(map);
  176.             draw_spritebank_offs( map->spr_bank,
  177.                                   map->x-map->win_left, map->y-map->win_top );
  178.             break;
  179.          }
  180.       if ( highLightOn )
  181.          highLightTile( mouse_x, mouse_y );
  182.       if ( showAttribsOn )
  183.          drawAttributes(map);
  184.       // if task to do, update screen on to synch. pages for page flipping
  185.       if ( task != TASK_NONE )
  186.          {
  187.          gui_draw_gadget();
  188.          update_map_data();
  189.          }
  190.       switch( task )
  191.          {
  192.          case TASK_SET_TILE_ATTRIBS:
  193.             gui_push();
  194.             setTileAttribs();
  195.             gui_pop();
  196.             task=TASK_NONE;
  197.             break;
  198.          case TASK_SET_OBJ_ATTRIBS:
  199.             gui_push();
  200.             setObjAttribs(map);
  201.             gui_pop();
  202.             task=TASK_NONE;
  203.             break;
  204.          case TASK_LOAD:
  205.             change_font(0);
  206.             if ( gui_get_string(0, 0, "^OK", "^CANCEL", "Load Map", 'O', 'C', mapFileName, 13, 120) )
  207.                {
  208.                pr2("yup, load it: %s", mapFileName);
  209.                if ( access(mapFileName, 0) )
  210.                   {
  211.                   sprintf(gb_util_str, "File not found: %s", mapFileName);
  212.                   gui_one_button(0,0, "^OK", gb_util_str, 'O');
  213.                   }
  214.                else
  215.                   {
  216.                   deinit_tile_map(map);
  217.                   if ( (map= load_edit_tile_map( mapFileName, "tileedit.inf", MAPWIN_LEFT, MAPWIN_RIGHT,
  218.                                                      MAPWIN_TOP, MAPWIN_BOTTOM ))
  219.                        != NULL )
  220.                      {
  221.                      initEditing();
  222.                      edited= 0;
  223.                      draw_all_tiles(map);
  224.                      draw_low_dressings(map);
  225.                      draw_high_dressings(map);
  226.                      x_page_flip(0,0);
  227.                      page= page ? 0 : 1;
  228.                      draw_all_tiles(map);
  229.                      draw_low_dressings(map);
  230.                      draw_high_dressings(map);
  231.                      }
  232.                   }
  233.                }
  234.             task=TASK_NONE;
  235.             break;
  236.          case TASK_SAVE:
  237.             if ( gui_get_string(0, 0, "^OK", "^CANCEL", "Save Map", 'O', 'C', mapFileName, 13, 120) )
  238.                {
  239.                if ( save_tile_map(map, mapFileName) )
  240.                   {
  241.                   sprintf(gb_util_str, "ERROR Saving: %s", mapFileName);
  242.                   gui_one_button(0,0, "^OK", gb_util_str, 'O');
  243.                   }
  244.                else
  245.                   {
  246.                   sprintf(gb_util_str, "Saved: %s", mapFileName);
  247.                   gui_one_button(0,0, "  ^OK  ", gb_util_str, 'O');
  248.                   }
  249.                }
  250.             edited= 0;
  251.             task=TASK_NONE;
  252.             break;
  253.          case TASK_EXIT:
  254.             if ( gui_two_button(0,0, "E^XIT", "^STAY",
  255.                                 "Changes not saved!", 'X', 'S') )
  256.                done=1;
  257.             task=TASK_NONE;
  258.             break;
  259.       }
  260.       // check for gui events and other events
  261.       event.d2=0;
  262.       // display misc data about map, and editing state
  263.       guiDoGadgetResult= gui_do_gadget(&event);
  264.       update_map_data();
  265.       if ( guiDoGadgetResult )
  266.          {
  267.          switch ( event.type )
  268.             {
  269.             case E_GUI:
  270.                pr2("gui id = %d curr_gadget = %d", event.d1, gui_list.num);
  271.                if ( event.d2 == ESC )
  272.                   {
  273.                   if ( edited )
  274.                      task=TASK_EXIT;
  275.                   else
  276.                      done=1;
  277.                   }
  278.                else
  279.                   {
  280.                   switch ( event.d1 )
  281.                      {
  282.                      case PB_HELP:
  283.                         gui_display_text_file( get_gui_path("ed_map.hlp"), gui_path );
  284.                         break;
  285.                      case PB_LEFT_ARROW:   // left arrow
  286.                         if ( leftTileInGroup > 0 )
  287.                            {
  288.                            leftTileInGroup--;
  289.                            positionInTileMenu++;
  290.                            if ( positionInTileMenu >= NUM_SELECTIONS )
  291.                               selectTilePosition(NUM_SELECTIONS);
  292.                            }
  293.                         gui_set_id_active( positionInTileMenu+SELECT_PBs_BASE_ID );
  294.                         break;
  295.                      case PB_RIGHT_ARROW:  // right arrow
  296.                         if ( map->ed_info->groups[tileGroup].end
  297.                               - map->ed_info->groups[tileGroup].start
  298.                               - leftTileInGroup > NUM_SELECTIONS )
  299.                            {
  300.                            leftTileInGroup++;
  301.                            positionInTileMenu--;
  302.                            if ( positionInTileMenu < 0 )
  303.                               selectTilePosition(1);
  304.                            }
  305.                         gui_set_id_active( positionInTileMenu+SELECT_PBs_BASE_ID );
  306.                         break;
  307.                      case PB_TOGGLE_RND:   // toggle rnd
  308.                         randomOn=!randomOn;
  309.                         break;
  310.                      case PB_TOGGLE_ATTRIBS:   // toggle display of tile attributes
  311.                         showAttribsOn=!showAttribsOn;
  312.                         break;
  313.                      case PB_PLACE_TILES:
  314.                         action= PLACE_TILE;
  315.                         selectTilePosition(1);
  316.                         deleteOn = 0;
  317.                         randomOn= 0;
  318.                         break;
  319.                      case PB_PLACE_HIDRESS:
  320.                         action= PLACE_HIDRESS;
  321.                         deleteOn = 0;
  322.                         selectObjectInGroup(1);
  323.                         randomOn= 0;
  324.                         break;
  325.                      case PB_PLACE_LODRESS:
  326.                         action= PLACE_LODRESS;
  327.                         deleteOn = 0;
  328.                         selectObjectInGroup(1);
  329.                         randomOn= 0;
  330.                         break;
  331.                      case PB_PLACE_ANIMS:
  332.                         action= PLACE_ANIMS;
  333.                         deleteOn = 0;
  334.                         selectAnimInGroup(1);
  335.                         randomOn= 0;
  336.                         break;
  337.                      case PB_NEXT:
  338.                         switch( action )
  339.                            {
  340.                            case PLACE_TILE:
  341.                               selectTileGroup( tileGroup+1 );
  342.                               break;
  343.                            case PLACE_HIDRESS:
  344.                            case PLACE_LODRESS:
  345.                               selectObjGroup( objectGroup+1 );
  346.                               break;
  347.                            }
  348.                         break;
  349.                      case PB_BACK:
  350.                         switch( action )
  351.                            {
  352.                            case PLACE_TILE:
  353.                               selectTileGroup( tileGroup-1 );
  354.                               break;
  355.                            case PLACE_HIDRESS:
  356.                            case PLACE_LODRESS:
  357.                               selectObjGroup( objectGroup-1 );
  358.                               break;
  359.                            }
  360.                         break;
  361.                      case PB_EXIT:  // exit, will add requester to double check this request!
  362.                         if ( edited )
  363.                            task=TASK_EXIT;
  364.                         else
  365.                            done=1;
  366.                         break;
  367.                      case PB_DEL_OBJ:   // erase objects
  368.                         deleteOn=!deleteOn;
  369.                         if ( deleteOn )
  370.                            {
  371.                            showDelete= 1;
  372.                            nextFlash=TICKS + FLASH_SPEED;
  373.                            cursorPbm= NULL;
  374.                            }
  375.                         break;
  376.                      case PB_SAVE: task=TASK_SAVE;  break;
  377.                      case PB_LOAD: task=TASK_LOAD;  break;
  378.                      case PB_SETUP: // edit tiles
  379.                         gui_push();
  380.                         editTileLib( map->tile_bitmaps, map->tilelib_size,
  381.                                       map->ed_info );
  382.                         // save tile library
  383.                         save_tile_lib( map );
  384.                         //save edit info
  385.                         handle=f_open( nearFName(map->edinfo_name), F_WRONLY);
  386.                         if ( handle != -1 )
  387.                            {
  388.                            f_write(handle, (char far *)map->ed_info, sizeof(ed_info_t));
  389.                            f_close( handle );
  390.                            }
  391.                         else
  392.                            pr2( "Error: can't open edit info file for writing" );
  393.                         gui_pop();
  394.                         initEditing();
  395.                         break;
  396.                      case PB_SELECT_1: selectObjTile(1);  break;
  397.                      case PB_SELECT_2: selectObjTile(2);  break;
  398.                      case PB_SELECT_3: selectObjTile(3);  break;
  399.                      case PB_SELECT_4: selectObjTile(4);  break;
  400.                      case PB_SELECT_5: selectObjTile(5);  break;
  401.                      case PB_SELECT_6: selectObjTile(6);  break;
  402.                      case PB_SELECT_7: selectObjTile(7);  break;
  403.                      case PB_SELECT_8: selectObjTile(8);  break;
  404.                     }
  405.                   }
  406.                break;
  407.                   case E_KEY:
  408.                      if ( event.sub_type == E_DOWN )
  409.                         {
  410.                         switch ( event.d2 )
  411.                            {
  412.                            case ESC :
  413.                               if ( edited )
  414.                                  task=TASK_EXIT;
  415.                               else
  416.                                  done=1;
  417.                               break;
  418.                            case END:
  419.                               move_state=MOVE_RIGHT;
  420.                               moveStep= MAPWIN_RIGHT- MAPWIN_LEFT;
  421.                               break;
  422.                            case HOME:
  423.                               move_state=MOVE_LEFT;
  424.                               moveStep= MAPWIN_RIGHT- MAPWIN_LEFT;
  425.                               break;
  426.                            case PGUP:
  427.                               move_state=MOVE_UP;
  428.                               moveStep= MAPWIN_BOTTOM-MAPWIN_TOP;
  429.                               break;
  430.                            case PGDN:
  431.                               move_state=MOVE_DOWN;
  432.                               moveStep= MAPWIN_BOTTOM-MAPWIN_TOP;
  433.                               break;
  434.                            case RIGHT:
  435.                               move_state=MOVE_RIGHT;
  436.                               moveStep= map->tile_width;
  437.                               break;
  438.                            case LEFT:
  439.                               move_state=MOVE_LEFT;
  440.                               moveStep= map->tile_width;
  441.                               break;
  442.                            case UP:
  443.                               move_state=MOVE_UP;
  444.                               moveStep= map->tile_height;
  445.                               break;
  446.                            case DOWN:
  447.                               move_state=MOVE_DOWN;
  448.                               moveStep= map->tile_height;
  449.                               break;
  450.                            case F1: selectObjTile(1);  break;
  451.                            case F2: selectObjTile(2);  break;
  452.                            case F3: selectObjTile(3);  break;
  453.                            case F4: selectObjTile(4);  break;
  454.                            case F5: selectObjTile(5);  break;
  455.                            case F6: selectObjTile(6);  break;
  456.                            case F7: selectObjTile(7);  break;
  457.                            case F8: selectObjTile(8);  break;
  458.                            }
  459.                         }
  460.                      else
  461.                         {
  462.                         if ( event.sub_type == E_UP )
  463.                            {
  464.                            switch ( event.d2 )
  465.                               {
  466.                               case RIGHT:
  467.                               case LEFT:
  468.                               case UP:
  469.                               case DOWN:
  470.                                  arrow_down--;
  471.                                  if ( arrow_down == 0 )
  472.                                     {
  473.                                     move_state=NO_MOVE;
  474.                                     }
  475.                                  break;
  476.                               }
  477.                            }
  478.                         }
  479.                      break;
  480.                  case E_L_BUTTON_DN:  drawActive=1;  break;
  481.                  case E_L_BUTTON_UP:
  482.                     drawActive=0;
  483.                     // force an update of current tile next time user presses button
  484.                     forceTileUpdate= 1;
  485.                     break;
  486.                  case E_R_BUTTON_DN:
  487.                     if ( action == PLACE_TILE )
  488.                        {
  489.                        rtBtnClickX= map->x+mouse_x-MAPWIN_LEFT;
  490.                        rtBtnClickY= map->y+mouse_y-MAPWIN_TOP;
  491.                        highLightOn=1;
  492.                        }
  493.                      else
  494.                        identifyObject( mouse_x,  mouse_y );
  495.                     break;
  496.                  case E_R_BUTTON_UP:
  497.                     highLightOn=0;
  498.                     forceTileUpdate=1;
  499.                     switch( action )
  500.                        {
  501.                        case PLACE_TILE: task= TASK_SET_TILE_ATTRIBS; break;
  502.                        default:
  503.                           identifyObject( mouse_x,  mouse_y );
  504.                           if ( identObjectInd != -1 )
  505.                              task= TASK_SET_OBJ_ATTRIBS;
  506.                           break;
  507.                         }
  508.                     break;
  509.                   }
  510.                }
  511.       if ( deleteOn )
  512.          identifyObject( mouse_x, mouse_y );
  513.       /* edit the map, draw stuff if required */
  514.       updateEdits(mouse_x, mouse_y);
  515.       // if not using arrow keys see if should move by mouse
  516.       if ( mouse_y <= MENU_BOTTOM )
  517.          drawActive= 0;
  518.       else
  519.          if ( move_state == NO_MOVE  )
  520.             {
  521.             get_mouse_movemap_state(map, &move_state);
  522.             moveStep= map->tile_width;
  523.             if ( moveStep > 12 )
  524.                moveStep=12;
  525.             }
  526.       move_limit_spritebank(map->spr_bank);
  527.       // scroll map?
  528.       if ( move_state != NO_MOVE )
  529.          {
  530.          move_map_vector(map, moveStep, move_state);
  531.          move_state= NO_MOVE;
  532.          dirty= 1;
  533.          }
  534.       /* draw the mouse */
  535.       if ( task == TASK_NONE )
  536.          gui_draw_mouse();
  537.       /* page flip */
  538.       x_page_flip(0,0);
  539.       page= page ? 0 : 1;
  540.       }
  541.    deinit_tile_map(map);
  542.    deinit_gb_erase();
  543.    deinit_events();
  544.    deinit_xmode_video();
  545.    deinit_timer();
  546. get_gui_path)
  547. /* ---------------
  548. ------- get_gui_path() -------------- February 21,1994 */
  549. char *get_gui_path(char *f)
  550. short limit( short num, short lowLimit, short highLimit )
  551. static BYTE far *getSpriteBitMap0( BYTE far *lib, short index )
  552. short inMapWindow( map_t far *map, short x, short y )
  553. static void drawSelBitmap( void )
  554. static void countAnims( void )
  555. static void displayAnimMenu(void)
  556. static void selectAnimIndex( short index )
  557. static void selectAnimInGroup( short num_select )
  558. static void selectAnimGroup( short group )
  559. static void storeOneAnim(void)
  560. static short delOneAnim(void)
  561. static void countSelObj( void )
  562. static void displayObjectMenu(void)
  563. static short getNumLibObjects( BYTE far *lib )
  564. static void selectObjIndex( short index )
  565. static void selectObjectInGroup( short num_select )
  566. static void selectRandomObj( void )
  567. static void selectObjGroup( short group )
  568. static void storeOneObject(void)
  569. static void identifyObject( short mouseX, short mouseY )
  570. static short delOneDress(void)
  571. static void displayTileMenu(void)
  572. static void selectRandomTile( void )
  573. static void selectTilePosition( short num_select )
  574. static void selectTileGroup( short group )
  575. static void selectObjTile( short num_select )
  576. static void storeOneTile(void)
  577. static void drawDressMouse(short mx, short my)
  578. static void updateEdits(short mouseX, short mouseY)
  579. static void flashDelete( void )
  580. static void update_map_data(void)
  581. static void drawAttrib( short attrib, short x, short y )
  582. static void drawAttributes( map_t far *map )
  583. static void setAttribRadioBtns( short attrib )
  584. static short getTileIndex( short tileRow, short tileCol )
  585. static void setSelectedAttribs( short attrib )
  586. static void setTileAttribs( void )
  587. static void setObjAttribs( map_t far *map )
  588. static void highLightTile(short mx, short my)
  589. static void initEditing( void )
  590. void set_gui_path(char *p)
  591. char *get_gui_path(char *f)
  592. short limit( short num, short lowLimit, short highLimit )
  593. static BYTE far *getSpriteBitMap0( BYTE far *lib, short index )
  594. short inMapWindow( map_t far *map, short x, short y )
  595. static void drawSelBitmap( void )
  596. static void countAnims( void )
  597. static void displayAnimMenu(void)
  598. static void selectAnimIndex( short index )
  599. static void selectAnimInGroup( short num_select )
  600. static void selectAnimGroup( short group )
  601. static void storeOneAnim(void)
  602. static short delOneAnim(void)
  603. static void countSelObj( void )
  604. static void displayObjectMenu(void)
  605. static short getNumLibObjects( BYTE far *lib )
  606. static void selectObjIndex( short index )
  607. static void selectObjectInGroup( short num_select )
  608. static void selectRandomObj( void )
  609. static void selectObjGroup( short group )
  610. static void storeOneObject(void)
  611. static void identifyObject( short mouseX, short mouseY )
  612. static short delOneDress(void)
  613. static void displayTileMenu(void)
  614. static void selectRandomTile( void )
  615. static void selectTilePosition( short num_select )
  616. static void selectTileGroup( short group )
  617. static void selectObjTile( short num_select )
  618. static void storeOneTile(void)
  619. static void drawDressMouse(short mx, short my)
  620. static void updateEdits(short mouseX, short mouseY)
  621. static void flashDelete( void )
  622. static void update_map_data(void)
  623. static void drawAttrib( short attrib, short x, short y )
  624. static void drawAttributes( map_t far *map )
  625. static void setAttribRadioBtns( short attrib )
  626. static short getTileIndex( short tileRow, short tileCol )
  627. static void setSelectedAttribs( short attrib )
  628. static void setTileAttribs( void )
  629. static void setObjAttribs( map_t far *map )
  630. static void highLightTile(short mx, short my)
  631. static void initEditing( void )
  632. void set_gui_path(char *p)
  633. char *get_gui_path(char *f)
  634. short limit( short num, short lowLimit, short highLimit )
  635. static BYTE far *getSpriteBitMap0( BYTE far *lib, short index )
  636. short inMapWindow( map_t far *map, short x, short y )
  637. static void drawSelBitmap( void )
  638. static void countAnims( void )
  639. static void displayAnimMenu(void)
  640. static void selectAnimIndex( short index )
  641. static void selectAnimInGroup( short num_select )
  642. static void selectAnimGroup( short group )
  643. static void storeOneAnim(void)
  644. static short delOneAnim(void)
  645. static void countSelObj( void )
  646. static void displayObjectMenu(void)
  647. static short getNumLibObjects( BYTE far *lib )
  648. static void selectObjIndex( short index )
  649. static void selectObjectInGroup( short num_select )
  650. static void selectRandomObj( void )
  651. static void selectObjGroup( short group )
  652. static void storeOneObject(void)
  653. static void identifyObject( short mouseX, short mouseY )
  654. static short delOneDress(void)
  655. static void displayTileMenu(void)
  656. static void selectRandomTile( void )
  657. static void selectTilePosition( short num_select )
  658. static void selectTileGroup( short group )
  659. static void selectObjTile( short num_select )
  660. static void storeOneTile(void)
  661. static void drawDressMouse(short mx, short my)
  662. static void updateEdits(short mouseX, short mouseY)
  663. static void flashDelete( void )
  664. static void update_map_data(void)
  665. static void drawAttrib( short attrib, short x, short y )
  666. static void drawAttributes( map_t far *map )
  667. static void setAttribRadioBtns( short attrib )
  668. static short getTileIndex( short tileRow, short tileCol )
  669. static void setSelectedAttribs( short attrib )
  670. static void setTileAttribs( void )
  671. static void setObjAttribs( map_t far *map )
  672. static void highLightTile(short mx, short my)
  673. static void initEditing( void )
  674. void set_gui_path(char *p)
  675. char *get_gui_path(char *f)
  676. short limit( short num, short lowLimit, short highLimit )
  677. static BYTE far *getSpriteBitMap0( BYTE far *lib, short index )
  678. short inMapWindow( map_t far *map, short x, short y )
  679. static v
  680. (oid drawSelBitmap( void )
  681. static void countAnims( void )
  682. static void displayAnimMenu(void)
  683. static void selectAnimIndex( short index )
  684. static void selectAnimInGroup( short num_select )
  685. static void selectAnimGroup( short group )
  686. static void storeOneAnim(void)
  687. static short delOneAnim(void)
  688. static void countSelObj( void )
  689. static void displayObjectMenu(void)
  690. static short getNumLibObjects( BYTE far *lib )
  691. static void selectObjIndex( short index )
  692. static void selectObjectInGroup( short num_select )
  693. static void selectRandomObj( void )
  694. static void selectObjGroup( short group )
  695. static void storeOneObject(void)
  696. static void identifyObject( short mouseX, short mouseY )
  697. static short delOneDress(void)
  698. static void displayTileMenu(void)
  699. static void selectRandomTile( void )
  700. static void selectTilePosition( short num_select )
  701. static void selectTileGroup( short group )
  702. static void selectObjTile( short num_select )
  703. static void storeOneTile(void)
  704. static void drawDressMouse(short mx, short my)
  705. static void updateEdits(short mouseX, short mouseY)
  706. static void flashDelete( void )
  707. static void update_map_data(void)
  708. static void drawAttrib( short attrib, short x, short y )
  709. static void drawAttributes( map_t far *map )
  710. static void setAttribRadioBtns( short attrib )
  711. static short getTileIndex( short tileRow, short tileCol )
  712. static void setSelectedAttribs( short attrib )
  713. static void setTileAttribs( void )
  714. static void setObjAttribs( map_t far *map )
  715. static void highLightTile(short mx, short my)
  716. static void initEditing( void )
  717. void set_gui_path(char *p)
  718.                     if ( mouse_y < map->win_top )
  719.                        break;
  720.          dirty=0;
  721.       if ( dirty )
  722.          {
  723.          }
  724.       else
  725.          update_tiles(map);
  726.          {
  727.          if ( dirty )
  728.             {
  729.             dirty=0;
  730.             }
  731.          }
  732.    return;
  733.    switch ( g->rect.type )
  734.    // store the first tile highlighted
  735.       hilightLeftCol= clickX/map->tile_width;
  736.       hilightRightCol= dragX/map->tile_width;
  737. clickY/map->tile_height;
  738.    clidragX/map->tile_width;
  739.    hilightFirstCol= clickX/map->tile_width;
  740.    hilightFirstRow= clickY/map->tile_height;
  741.    hilightFirstCol= clickX/map->tile_width;
  742.    hilightFirstRow= clickY/map->tile_height;
  743.                   fade_in(pal, 2);
  744.    fade_in(pal, 2);
  745.    fade_out(pal, 2);
  746.    fade_out(pal, 2);
  747. BYTE palette[768];
  748.    fade_out(1);
  749.    for( i= 0; i
  750.    setvgapalette((char far *)palette);
  751.    /* this bit of code makes the dressing appear transparent when
  752.       drawn on the gui rect, by setting color zero to match the rect color */
  753.    for( i= 0; i
  754.    setvgapalette((char far *)palette);
  755.    /* this bit of code makes the dressing appear transparent when
  756.       drawn on the gui rect, by setting color zero to match the rect color */
  757.       eraseAndDraw();
  758.    /* page flip */
  759.       x_page_flip(0,0);
  760.       page= page ? 0 : 1;
  761.    fade_in(pal, 1);
  762.    eraseAndDraw();
  763.       /* page flip */
  764. /* draw the mouse */
  765.    // erase old stuff
  766.    draw_erase_rects(&(gb_h[page]));
  767.    // page flip
  768.    x_page_flip(0,0);
  769.    page= page ? 0 : 1;
  770.    // erase old stuff
  771.    draw_erase_rects(&(gb_h[page]));
  772.       updateScreenInfo(level);
  773.    if ( !mouse_present )
  774.       die("Mouse driver not loaded.");
  775.       /* draw the mouse */
  776.       gui_draw_mouse();
  777.       gui_draw_mouse();
  778.       /* draw the mouse */
  779.       gui_draw_mouse();
  780.    eraseAndDraw();
  781.    eraseAndDraw();
  782. //   drawScreen();
  783. //   drawScreen();
  784.    drawScreen();
  785.    // draw screen, flip pages, draw on other page too
  786.    drawScreen();
  787.    eraseAndDraw();
  788.    updateScreenInfo(level);
  789.    /* page flip */
  790.    x_page_flip(0,0);
  791.    page= page ? 0 : 1;
  792.    drawScreen();
  793.    eraseAndDraw();
  794.    updateScreenInfo(level);
  795.    /* erase old stuff */
  796.    draw_erase_rects(&(gb_h[page]));
  797.       x_page_flip(0,0);
  798.       page= page ? 0 : 1;
  799.    /* erase old stuff */
  800.    draw_erase_rects(&(gb_h[page]));
  801.    /* erase old stuff */
  802.       eraseAndDraw();
  803.       x_page_flip(0,0);
  804.       page= page ? 0 : 1;
  805.    eraseAndDraw();
  806.    updatedScreenInfo(level);
  807. short level;
  808. static void updateScreenInfo(short level)
  809.    fade_in(pal, 1);
  810.    fade_in(pal, 1);
  811.    fade_in(pal, 1);
  812.    // set palette to dark intially
  813.    for( i= 0; i < 768; i++ )
  814.       palette[i]= 0;
  815.    setvgapalette((char far *)palette);
  816. short i;
  817.    fade_out(1);
  818.    fade_out(1);
  819. static short joyLeft, joyCentHoriz, joyRight, joyUp, joyDown, joyCentVert;
  820. static short joyLeft, joyCentHoriz, joyRight, joyUp, joyDown, joyCentVert;
  821.    switch(joyX)
  822.       {
  823.       case JOY_LEFT:
  824.          // limit turn rate
  825.          if ( nextTurn == -1 || fast_tick > nextTurn )
  826.             {
  827.             gguyRotation= chgRotation( gguyRotation, -1 );
  828.             set_bitmap( gguy, gguyRotation );
  829.             nextTurn = fast_tick+ TURN_DELAY;
  830.             if ( joyY == JOY_UP )
  831.                {
  832.                gguy->dx= tankFwdX[ gguyRotation ];
  833.                gguy->dy= tankFwdY[ gguyRotation ];
  834.                }
  835.             if ( joyY == JOY_DOWN )
  836.                {
  837.                gguy->dx= tankRevX[ gguyRotation ];
  838.                gguy->dy= tankRevY[ gguyRotation ];
  839.                }
  840.             }
  841.          break;
  842.       case JOY_CENTER:
  843.          nextTurn = -1;
  844.          break;
  845.       case JOY_RIGHT:
  846.          // limit turn rate
  847.          if ( nextTurn == -1 || fast_tick > nextTurn )
  848.             {
  849.             gguyRotation= chgRotation( gguyRotation, 1 );
  850.             set_bitmap( gguy, gguyRotation );
  851.             nextTurn = fast_tick+ TURN_DELAY;
  852.             if ( joyY == JOY_UP )
  853.                {
  854.                gguy->dx= tankFwdX[ gguyRotation ];
  855.                gguy->dy= tankFwdY[ gguyRotation ];
  856.                }
  857.             if ( joyY == JOY_DOWN )
  858.                {
  859.                gguy->dx= tankRevX[ gguyRotation ];
  860.                gguy->dy= tankRevY[ gguyRotation ];
  861.                }
  862.             }
  863.          break;
  864.       }
  865. static short joyX = JOY_CENTER, joyY=JOY_CENTER;
  866. static short joyLeft, joyCentHoriz, joyRight, joyUp, joyDown, joyCentVert;
  867. static short joyLeft, joyCentHoriz, joyRight, joyUp, joyDown, joyCentVert;
  868. static short joyX = JOY_CENTER, joyY=JOY_CENTER;
  869. static short joyX = JOY_CENTER, joyY=JOY_CENTER;
  870. enum joyPos { JOY_LEFT, JOY_CENTER, JOY_RIGHT, JOY_UP, JOY_DOWN };
  871. enum joyPos { JOY_LEFT, JOY_CENTER, JOY_RIGHT, JOY_UP, JOY_DOWN };
  872. X_CENTER,
  873.             gguy->dx= tankFwdX[ gguyRotation ];
  874.             gguy->dy= tankFwdY[ gguyRotation ];
  875.             break;
  876.             joyY= Y_CENTER;
  877.             gguy->dx=gguy->dy=0;
  878.             break;
  879.            joyY= Y_DOWN;
  880.             gguy->dx= tankRevX[ gguyRotation ];
  881.             gguy->dy= tankRevY[ gguyRotation ];
  882.            break;
  883.          // latch last joystick position
  884.          // latch joystick position
  885.          case E_JOY_X_LEFT:   joyX= X_LEFT;   break;
  886.          case E_JOY_X_CENTRE: joyX= X_CENTER; break;
  887.          case E_JOY_X_RIGHT:  joyX= X_RIGHT;  break;
  888.          case E_JOY_Y_UP:     joyY= Y_UP;     break;
  889.          case E_JOY_Y_CENTRE: joyY= Y_CENTER; break;
  890.          case E_JOY_Y_DOWN:   joyY= Y_RIGHT;  break;
  891.              case E_JOY_X_CENTRE: controlX= X_CENTER; break;
  892.              case E_JOY_Y_UP:     controlY= Y_UP;     break;
  893.              case E_JOY_Y_CENTRE: controlY= Y_CENTER; break;
  894.              case E_JOY_Y_DOWN:   controlY= Y_RIGHT;  break;
  895.              case E_JOY_Y_CENTRE: controlY= Y_CENTER; break;
  896.                   case RIGHT:
  897.                     gguyRotation= chgRotation( gguyRotation, 1 );
  898.                     set_bitmap( gguy, gguyRotation );
  899.                     break;
  900.                   case LEFT:
  901.                     gguyRotation= chgRotation( gguyRotation, -1 );
  902.                     set_bitmap( gguy, gguyRotation );
  903.                     break;
  904.                            case UP:
  905.                     gguy->dx= tankFwdX[ gguyRotation ];
  906.                     gguy->dy= tankFwdY[ gguyRotation ];
  907.                     break;
  908.                            case DOWN:
  909.                     gguy->dx= tankRevX[ gguyRotation ];
  910.                     gguy->dy= tankRevY[ gguyRotation ];
  911.                     break;
  912.          case E_JOY_X_CENTRE: controlX= X_CENTER; break;
  913. ;break;
  914. controlY= Y_CENTER;
  915.             if ( controlY == Y_UP )
  916.                {
  917.                gguy->dx= tankFwdX[ gguyRotation ];
  918.                gguy->dy= tankFwdY[ gguyRotation ];
  919.                }
  920.             if ( controlY == Y_DOWN )
  921.                {
  922.                gguy->dx= tankRevX[ gguyRotation ];
  923.                gguy->dy= tankRevY[ gguyRotation ];
  924.                }
  925.             if ( controlY == Y_UP )
  926.                {
  927.                gguy->dx= tankFwdX[ gguyRotation ];
  928.                gguy->dy= tankFwdY[ gguyRotation ];
  929.                }
  930.             if ( controlY == Y_DOWN )
  931.                {
  932.                gguy->dx= tankRevX[ gguyRotation ];
  933.                gguy->dy= tankRevY[ gguyRotation ];
  934.                }
  935.             if ( controlY == Y_UP )
  936.                {
  937.      case Y_UP:
  938.                }
  939.             if ( controlY == Y_DOWN )
  940.                {
  941.       case Y_DOWN:
  942.          gguy->dx= tankRevX[ gguyRotation ];
  943.          gguy->dy= tankRevY[ gguyRotation ];
  944.          break;
  945. tankRevY[ gguyRotation ];
  946. tankRevX[ gguyRotation ];
  947.                }
  948.             if ( controlY == Y_UP )
  949.                {
  950.                gguy->dx= tankFwdX[ gguyRotation ];
  951.                gguy->dy= tankFwdY[ gguyRotation ];
  952.                }
  953.             if ( controlY == Y_DOWN )
  954.                {
  955.                gguy->dx= tankRevX[ gguyRotation ];
  956.                gguy->dy= tankRevY[ gguyRotation ];
  957.                }
  958. static short keyX = X_CENTER, keyY=Y_CENTER;
  959. static short controlX = X_CENTER, controlY=Y_CENTER;
  960. static short controlY = Y_CENTER, controlY=Y_CENTER;
  961. // static long badGuysChgDirNext[ NUM_BADGUY_SPRITES ];
  962.    //--- check for missiles hitting bad guys
  963.    if( (sPtr = detect_collisions(0, missileBank, badGuyBank) ) != NULL )
  964.     {
  965.     sPtr->change_mode = SPR_CHG_DEAD;  // kill bad guy
  966.     start_next_in_spritebank(explodeBank,   SPR_CHG_FORW_DIE,
  967.                                SPR_NO_LIMITS, sPtr->x+(sPtr->curr_width>>2),
  968.                                sPtr->y+(sPtr->curr_height>>2), 0, 0);
  969.     badGuysHit++;
  970.     badGuysAlive--;
  971.     }
  972.